package org.jiuling.validation.spring.handle;

import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import org.jiuling.basics.exception.BasicsException;
import org.jiuling.basics.util.ClassUtil;
import org.jiuling.basics.validation.*;
import org.jiuling.validation.spring.annotation.Unique;
import org.springframework.stereotype.Component;

/**
 * 唯一校验
 * @author 紫灵
 * @date 2024年12月28日 00时02分43秒
 */
@Component
public class UniqueValidator implements ConstraintValidator<Unique, Object> {

    /** 参数名称 */
    private String[] paramNames;

    @Override
    public void initialize(Unique constraintAnnotation) {
        ConstraintValidator.super.initialize(constraintAnnotation);
        this.paramNames = constraintAnnotation.paramNames();
    }

    @Override
    public boolean isValid(Object value, ConstraintValidatorContext context) {
        // 校验对象本身是否为空与参与校验的参数是否为空，如果为空则不进行校验
        if (ObjectVerify.isNull(value) || ArrayVerify.isEmpty(paramNames)) return true;

        // 定义字段中是否存在值
        boolean existValue = false;

        try {
            for (String paramName : paramNames) {
                Object fieldValue = ClassUtil.getFieldValue(value, paramName);
                // 判断是否为基础类型，如果不为基础类型则跳过循环进行下一循环
                if (!ObjectVerify.isBaseType(fieldValue)) continue;
                // 判断对象是否为空，如果为空则进入下一循环
                if (ObjectVerify.isNull(fieldValue)) continue;

                // 定义当前字段是否存在值
                boolean currentExistValue = false;

                // 判断值为String并且值不为空
                if (fieldValue instanceof String str){
                    if (!StringVerify.isBlank(str)) {
                        currentExistValue = true;
                    }
                // 判断值为Integer并且值不为空
                }else if (fieldValue instanceof Integer i){
                    if (!IntegerVerify.isBlank(i)) {
                        currentExistValue = true;
                    }
                // 判断值为Long并且值不为空
                }else if (fieldValue instanceof Long l){
                    if (!LongVerify.isBlank(l)) {
                        currentExistValue = true;
                    }
                }

                // 判断当前字段是否存在值
                if (currentExistValue){
                    // 判断字段中存在值，如果存在值则返回false
                    if (existValue){
                        return false;
                    }
                    // 字段中存在第一个值
                    existValue = currentExistValue;
                }
            }
        } catch (BasicsException ignored) {
        }

        // 如果字段中存在值，则返回true
        return BooleanVerify.isTrue(existValue);
    }
}
